home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / ip / ka9q / net_src.arc / bsd_io.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-05-08  |  7.7 KB  |  388 lines
  1. /* OS- and machine-dependent stuff for 4.[23] BSD UNIX */
  2.  
  3. /*
  4.     FILE: UNIX.io.c
  5.     
  6.     Routines:
  7.         ioinit()
  8.         iostop()
  9.         asy_init()
  10.         asy_stop()
  11.         asy_speed()
  12.         asy_output()
  13.         asy_recv()
  14.         dir()
  15.     Written or converted by Mikel Matthews, N9DVG
  16.     
  17.     If you want to use the select code, define SELECT in the makefile or
  18.     in this file.
  19. */
  20.  
  21. #include <stdio.h>
  22. #include <sys/types.h>
  23. #include <sgtty.h>
  24. #include <sys/file.h>
  25. #include <sys/dir.h>
  26. #include <sys/time.h>
  27. #include "global.h"
  28. #include "mbuf.h"
  29. #include "internet.h"
  30. #include "iface.h"
  31. #include "unix.h"
  32. #include "cmdparse.h"
  33.  
  34. struct asy asy[ASY_MAX];
  35.  
  36. struct interface *ifaces;
  37.  
  38. struct sgttyb mysavetty, savecon;
  39. int    IORser[ASY_MAX];
  40. /*
  41. int    IOWser;
  42. */
  43. char *ttbuf;
  44.  
  45.  
  46. /* Called at startup time to set up console I/O, memory heap */
  47. ioinit()
  48. {
  49.     struct sgttyb ttybuf;
  50.     unsigned grabcore();
  51.     char *malloc();
  52.  
  53.     /* Interrupts use a special stack deep in data space.
  54.      * Calls to sbrk() (invoked by malloc when it needs more memory
  55.      * from the system) at interrupt time will fail because sbrk()
  56.      * will think that the stack has overwritten the heap. So
  57.      * grab all the memory we can now for the heap so that malloc
  58.      * won't have to call sbrk and alloc_mbuf() won't fail unnecessarily
  59.      * at interrupt time.
  60.      */
  61.     ioctl(0,TIOCGETP,&ttybuf);
  62.     savecon = ttybuf;
  63.     ttybuf.sg_flags &= ~ECHO;
  64.     ttybuf.sg_flags |= CBREAK;
  65.     ioctl(0,TIOCSETP,&ttybuf);
  66. }
  67. /* Called just before exiting to restore console state */
  68. iostop()
  69. {
  70.     struct sgttyb ttybuf;
  71.     setbuf(stdout,NULLCHAR);
  72.     free(ttbuf);
  73.     ioctl(0,TIOCGETP,&ttybuf);
  74.     ttybuf.sg_flags &= ~RAW;
  75.     ioctl(0,TIOCSETP,&ttybuf);
  76.     while(ifaces != NULLIF){
  77.         if(ifaces->stop != NULLFP)
  78.             (*ifaces->stop)(ifaces->dev);
  79.         ifaces = ifaces->next;
  80.     }
  81.     ioctl(0,TIOCSETP,&savecon);
  82. }
  83.  
  84. /* Initialize asynch port "dev" */
  85. int slipisopen;
  86. int
  87. asy_init(dev,arg1,arg2,bufsize)
  88. int16 dev;
  89. char *arg1,*arg2;
  90. unsigned bufsize;
  91. {
  92.     register struct asy *ap;
  93.     extern struct interface *ifaces;
  94.     struct sgttyb   sgttyb;
  95.     ap = &asy[dev];
  96.     /*
  97.     printf("asy_init: called\n");
  98.     */
  99.  
  100.     if ( ap == NULL)
  101.     {
  102.         return(-1);
  103.     }
  104.     ap->tty = malloc(strlen(arg2)+1);
  105.     strcpy(ap->tty, arg2);
  106.  
  107.     printf("asy_init: tty name = %s\n", ap->tty);
  108.     
  109.  
  110.     if ((IORser[dev] = open (ap->tty, (O_RDWR), 0)) < 0)
  111.     {
  112.         perror ("Could not open device IORser");
  113.         return (-1);
  114.     }
  115. /*
  116.     if ((IOWser = open (ap->tty, (O_WRONLY), 0)) < 0)
  117.     {
  118.         perror ("Could not open device IOWser");
  119.         return (-1);
  120.     }
  121. */
  122.  /* 
  123.   * get the stty structure and save it 
  124.   */
  125.  
  126.     if (ioctl (IORser[dev], TIOCGETP, &mysavetty) < 0)
  127.     {
  128.         perror ("ioctl failed on device");
  129.         return (-1);
  130.     }
  131.  /* 
  132.   * copy over the structure 
  133.   */
  134.  
  135.     sgttyb = mysavetty;
  136.     sgttyb.sg_flags = RAW;
  137.     sgttyb.sg_ispeed = sgttyb.sg_ospeed = B9600;
  138.  
  139.  /* 
  140.   * set up the parity and enter RAW mode 
  141.   */
  142.     sgttyb.sg_flags = (RAW | ANYP | CRMOD);
  143.  /* 
  144.   * now set the modes and flags 
  145.   */
  146.     if (ioctl (IORser[dev], TIOCSETP, &sgttyb) < 0)
  147.     {
  148.         perror ("ioctl could not set parameters for IORser");
  149.         return (-1);
  150.     }
  151. /*
  152.     if (ioctl (IOWser, TIOCSETP, &sgttyb) < 0)
  153.     {
  154.         perror ("ioctl could not set parameters for IOWser");
  155.         return (-1);
  156.     }
  157. */
  158.  
  159.     return (0);
  160. }
  161.  
  162. int
  163. asy_stop(dev)
  164. int dev;
  165. {
  166. }
  167.  
  168. /* Set asynch line speed */
  169. int
  170. asy_speed(dev,speed)
  171. int16 dev;
  172. int speed;
  173. {
  174.     struct sgttyb sgttyb;
  175.  
  176.     if(speed == 0 || dev >= nasy)
  177.         return(-1);
  178.     /*
  179.     printf("asy_speed: Setting speed for device %d to %d\n",dev, speed);
  180.     */
  181.     asy[dev].speed = speed;
  182.  
  183.     if (ioctl (IORser[dev], TIOCGETP, &sgttyb) < 0)
  184.     {
  185.         perror ("ioctl could not set parameters");
  186.         return (-1);
  187.     }
  188.     switch(speed)
  189.     {
  190.         case 0:
  191.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = B0;
  192.             break;
  193.         case 50:
  194.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = B50;
  195.             break;
  196.         case 75:
  197.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = B75;
  198.             break;
  199.         case 110:
  200.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = B110;
  201.             break;
  202.         case 134:
  203.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = B134;
  204.             break;
  205.         case 150:
  206.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = B150;
  207.             break;
  208.         case 200:
  209.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = B200;
  210.             break;
  211.         case 300:
  212.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = B300;
  213.             break;
  214.         case 600:
  215.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = B600;
  216.             break;
  217.         case 1200:
  218.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = B1200;
  219.             break;
  220.         case 1800:
  221.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = B1800;
  222.             break;
  223.         case 2400:
  224.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = B2400;
  225.             break;
  226.         case 4800:
  227.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = B4800;
  228.             break;
  229.         case 9600:
  230.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = B9600;
  231.             break;
  232.         /*
  233.         case EXTA:
  234.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = EXTA;
  235.             break;
  236.         case EXTB:
  237.             sgttyb.sg_ispeed = sgttyb.sg_ospeed = EXTB;
  238.             break;
  239.         */
  240.         default:
  241.             printf("asy_speed: Unknown speed (%d)\n", speed);
  242.             break;
  243.     }
  244. /*
  245.     printf("speed = %d\n", sgttyb.sg_ispeed);
  246.     */
  247.     if (ioctl (IORser[dev], TIOCSETP, &sgttyb) < 0)
  248.     {
  249.         perror ("ioctl could not set parameters for IORser");
  250.         return (-1);
  251.     }
  252. /*
  253.     if (ioctl (IOWser, TIOCSETP, &sgttyb) < 0)
  254.     {
  255.         perror ("ioctl could not set parameters for IOWser");
  256.         return (-1);
  257.     }
  258. */
  259.     return(0);
  260. }
  261. /* Send a buffer to serial transmitter */
  262. asy_output(dev,buf,cnt)
  263. unsigned dev;
  264. char *buf;
  265. unsigned short cnt;
  266. {
  267.     /*
  268.     printf("asy_output called. dev = %x, cnt = %d\n", dev, cnt);
  269.     printf("buf=%s\n", buf);
  270.     fflush(stdout);
  271.     */
  272.     
  273.     if(dev >= nasy)
  274.         return(-1);
  275.     if ( write(IORser[dev], buf, (int)cnt) < cnt)
  276.     {
  277.         perror("asy_output");
  278.         printf("asy_output: error in writing to device %d\n", dev);
  279.         return(-1);
  280.     }
  281.     return(0);
  282. }
  283. /* Receive characters from asynch line
  284.  * Returns count of characters read
  285.  */
  286. unsigned
  287. asy_recv(dev,buf,cnt)
  288. int dev;
  289. char *buf;
  290. unsigned cnt;
  291. {
  292.     unsigned tot;
  293.     long amount;
  294.  
  295. #ifdef SELECT
  296.     int    mask;
  297.     int    writemask;
  298.     int    ok;
  299.     struct timeval timeout;
  300.     timeout.tv_sec = 0;
  301.     timeout.tv_usec = 35;
  302.     mask = (1<<IORser[dev]);
  303.     writemask = (1<<IORser[dev]);
  304.     ok = 0;
  305.     tot = 0;
  306.     ok = select(mask, &mask, 0, 0, &timeout);
  307.     if ( mask & (1<<IORser[dev]))
  308.     {
  309.         tot = read(IORser[dev], buf, cnt);
  310.     }
  311.     return (tot);
  312. #else
  313.     tot = 0;
  314.     amount = 0;
  315.     if ( ioctl( IORser[dev], FIONREAD, &amount ) != -1)
  316.     {
  317.         if ( amount > 0)
  318.         {
  319.             /*
  320.             printf("ASY_RECV: amount = %d\n", amount);
  321.             printf("ASY_RECV: cnt = %d\n", cnt);
  322.             */
  323.             tot = read(IORser[dev], buf, (int)cnt);
  324.             /*
  325.             printf("READ %d\n", tot);
  326.             */
  327.         }
  328.     }
  329.     return (tot);
  330. #endif SELECT
  331. }
  332. /* Create a directory listing in a temp file and return the resulting file
  333.  * descriptor. If full == 1, give a full listing; else return just a list
  334.  * of names.
  335.  *
  336.  * This function is very dependent on the workings of Aztec standard I/O;
  337.  * it uses their mechanism for generating and deleting temporary files.
  338.  */
  339. FILE *
  340. dir(path,full)
  341. char *path;
  342. int full;
  343. {
  344.     FILE *fp;
  345.     char cmd[50];
  346.     char name[MAXNAMLEN],*tmpnam(),*malloc();
  347.     tmpnam(name);
  348.  
  349.     if ( path[0] == '\0' )
  350.     {
  351.         path = ".";
  352.         /*
  353.         printf("Path = %s\n", path);
  354.         */
  355.     }
  356.     /*
  357.     printf("DIR: tempname = %s, path = %s\n",name, path);
  358.     */
  359.  
  360.     if(full){
  361.         sprintf(cmd,"ls -l %s > %s",path,name);
  362.         system(cmd);
  363.     } else {
  364.         sprintf(cmd, "ls %s > %s", path, name);
  365.         system(cmd);
  366.     }
  367.     if( (fp = fopen(name,"r")) == NULL)
  368.     {
  369.         perror("fopen");
  370.     }
  371.     /* Set up the magic cookies inside the file structure so that the
  372.      * temporary file gets deleted later when the file is closed
  373.      */
  374.     (void)unlink(name);
  375.     return (fp);
  376. }
  377. asy_ioctl(interface, argc, argv)
  378. struct interface *interface;
  379. int    argc;
  380. char    *argv[];
  381. {
  382.     if (argc < 1) {
  383.         printf("%d\r\n", asy[interface->dev].speed);
  384.         return 0;
  385.     }
  386.     return asy_speed(interface->dev, atoi(argv[0]));
  387. }
  388.